package org.example.test2;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

public class LambdaParseLocalDate {

    public static void main(String[] args) {
        LocalDate startTime = LocalDate.now();
        LocalDate endTime = LocalDate.of(2024,12,8);
        List<String> strings = new ArrayList<>();
        while (startTime.isBefore(endTime)) {
//         strings.add(startTime.format(DateTimeFormatter.ISO_DATE));
            strings.add(startTime.toString());
            startTime = startTime.plusMonths(1);
        }
        //1.基本的Lambda表达式
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE;
        List<LocalDate> record1= strings.stream()//strings.stream()是将List<String> 转换为 Stream<String>
                .map(e->LocalDate.parse(e,formatter))//对流中的每个字符串应用 LocalDate.parse 方法，将其解析为 LocalDate 对象。
                .collect(Collectors.toList());//将解析后的 LocalDate 对象收集到一个新的列表中
        record1.forEach(System.out::println);

        /**
         * 有了一个流对象，你可以链式调用多种中间操作（如 map、filter、sorted 等）和终端操作（如 collect、forEach、reduce 等）来处理数据
         */
//    常见流操作
//    中间操作
//    map(Function<T, R> mapper)：对流中的每个元素应用一个函数，并返回一个新的流。
//    filter(Predicate<T> predicate)：过滤流中的元素，只保留满足条件的元素。
//    sorted(Comparator<? super T> comparator)：对流中的元素进行排序。
//    distinct()：去除流中的重复元素。
//    limit(long maxSize)：截断流，使其最多包含 maxSize 个元素。
//    skip(long n)：跳过流中的前 n 个元素。
//    终端操作
//    collect(Collector<? super T, A, R> collector)：将流中的元素收集到一个集合或其他数据结构中。
//    forEach(Consumer<? super T> action)：对流中的每个元素执行一个操作。
//    reduce(BinaryOperator<T> accumulator)：对流中的元素进行归约操作。
//    anyMatch(Predicate<? super T> predicate)：检查流中是否至少有一个元素满足给定的条件。
//    allMatch(Predicate<? super T> predicate)：检查流中的所有元素是否都满足给定的条件。
//    noneMatch(Predicate<? super T> predicate)：检查流中的所有元素是否都不满足给定的条件。
//    findFirst()：返回流中的第一个元素。
//    findAny()：返回流中的任意一个元素。
        //2.带有异常处理的Lambda表达式
        List<LocalDate> record2=strings.stream()
                .map(e->{
                    try{
                        return LocalDate.parse(e,formatter);
                    }catch (Exception exception){
                        return null;
                    }
                })
                .filter(Objects::nonNull)//过滤解析失败的null值
                .collect(Collectors.toList());
        record2.forEach(System.out::println);

        //3.使用方法引用
        Function<String,LocalDate> functionName=e->LocalDate.parse(e,formatter);
        List<LocalDate> record3= strings.stream()
                .map(functionName)
                .collect(Collectors.toList());
        record3.forEach(System.out::println);
        //4.使用 Stream 的 peek 方法进行调试
        List<LocalDate> records4 = strings.stream()
                .peek(e -> System.out.println("Parsing: " + e)) // 打印解析前的字符串
                .map(e -> LocalDate.parse(e, formatter))
                .collect(Collectors.toList());
        records4.forEach(System.out::println);

        // 5.使用 Collectors.mapping 方法
        List<LocalDate> records5 = strings.stream()
                .collect(Collectors.mapping(e -> LocalDate.parse(e, formatter), Collectors.toList()));
        records5.forEach(System.out::println);


    }
}
